COMMENT ⊗   VALID 00058 PAGES
C REC  PAGE   DESCRIPTION
C00001 00001
C00008 00002	purpose and use of this file
C00009 00003	DEFINE RECORDS=[
C00016 00004	XX(MENU,	"MENU",	"gives a list of toplevel instructions")
C00017 00005	XX(RES_WORDS,	"RES",	"gives a list of reserved words")
C00019 00006	XX(RES_HELP,	"RESH",	"gives one line descriptions of the reserved words")
C00027 00007	XX(DISPLAYS,	"DISP",	"describes display commands")
C00029 00008	XX(POWER,	"POW",	"describes turning on and off the power to the arms")
C00031 00009	XX(PUMA,	"PUMA",	"describes use of PUMA arms with POINTY")
C00036 00010	XX(ELF,		"ELF",	["gives information on the ELF, or PDP-11 interface"])
C00039 00011	XX(VT05,	"VT05",	"describes VT05")
C00040 00012	XX(OPERATIONS,	"OPER",	"shows available operators and functions")
C00041 00013	  XX(LOGICALOPS,"LOGIC","gives a list of logical operators")
C00042 00014	  XX(RELATIONALOPS,"RELAT","list of relational operators")
C00043 00015	  XX(ARITHOPS,	"ARITH","gives a list of arithmetic operators")
C00044 00016	    XX(BINARYOPS,"BIN",	"list of binary operators")
C00045 00017	    XX(SCALAROPS,"SCOPS","list of operations that give a scalar result")
C00048 00018	    XX(VECTOROPS,"VTOPS","list of operations giving vector result")
C00050 00019	    XX(ROTOPS,	"RTOPS","list of operations giving rot result")
C00051 00020	    XX(FRAMEOPS,"FROPS","list of operations giving frame results")
C00052 00021	    XX(TRANSOPS,"TROPS","list of operations giving trans/frame result")
C00053 00022	    XX(EXTRACTIONOPS,"EXOPS","extraction functions")
C00054 00023	    XX(IMPLICITOPS,	"IMPOPS","implicit data types")
C00057 00024	  XX(FUNCTIONS,	"FUNCT","gives a list of available functions")
C00058 00025	XX(EXPRESSIONS,	"EXP",	"valid expressions")
C00061 00026	XX(FILE,	"FILE",	"Gives the file management commands")
C00067 00027	XX(ESCAPE_I,	"ESC_I","ESCAPE I command")
C00069 00028	XX(STATEMENTS,	"STATE","classes of statements")
C00070 00029	  XX(ASSIGNMENT,["←"],	"assignment statement")
C00072 00030	  XX(MOTION,	"MOT",	"list of motion commands")
C00073 00031	    XX(OPEN,	"OPEN",	"opens the hand")
C00074 00032	    XX(CLOSE,	"CLOS",	"similar to OPEN")
C00075 00033	    XX(MOVE,	"MOVE",	"moves the arm")
C00079 00034	    XX(DRIVE,	"DRIVE","driving single joints")
C00080 00035	    XX(CENTER,	"CENTER","does a grasp")
C00081 00036	    XX(GATHER,	"GATH","gathers force and torque data")
C00083 00037	    XX(GRAPH,	"GRAPH","explains the GRAPH command")
C00084 00038	  XX(DECLARATION,	"DECL",	"declaration statement")
C00086 00039	  XX(CONTROL,	"CONT",	"list of control statements")
C00088 00040	  XX(OTHER_AL,	"OTHERS","these are some of the other AL instructions")
C00089 00041	  XX(INTER,	"INTER","these instructions facilitate interaction")
C00090 00042	    XX(EDIT,	"EDIT",	"permits the changing of the value of simple variables")
C00092 00043	    XX(EEDIT,	"EEDIT","writes the macro in a file and swaps to E")
C00094 00044	    XX(DELETE,	"DEL",	"deletes some or all variables")
C00096 00045	    XX(SETSTATUS,"SETS","explains the SETSTATUS and RESETSTATUS commands")
C00098 00046	XX(ERROR,	"ERROR", "talks about how to handle errors")
C00099 00047	  XX(NO_ARM,	"NOARM", "what to do if there is no arm action")
C00101 00048	  XX(PARSE,	"PARSE", "explanation of error messages")
C00103 00049	XX(SYNTAX,	"SYNTAX","syntax of statements")
C00104 00050	  XX(SYNFILE,	"FILSYN","syntax of file management commands")
C00105 00051	  XX(SYNDIS,	"DISSYN","syntax of display commands")
C00106 00052	  XX(SYNDECL,	"DECL",	"syntax of declaration commands")
C00108 00053	  XX(SYNMIS,	NULL,	["	Syntax of other commands will be added
C00109 00054	XX(DONE,	"DONE",	"quits help mode")
C00110 00055	XX(DEBUG,	"DEBUG","details of the high level debugger")
C00115 00056	XX(SYSTEM,	"SYSTEM","building up a new POINTY system")
C00120 00057	XX(BAIL,	"BAIL",	"describes the SAIL debugger and how to get at it")
C00122 00058	]
C00123 ENDMK
C⊗;
COMMENT purpose and use of this file
	This file is used as a source file in the compilation of
	HELP0, and data from this file eventually ends up in
	HELP.NUM,HELP.KEY,HELP.DAT

	If you change this file, execute HELP0.SAI to generate new
	data files for the POINTY program.

	Dont put any more semicolons on this page or the SAIL compiler
	will complain.
							MSM 8/31/79
	If for some reason, HELP0.SAI does not compile or
	execute successfully, compare this file with HELP0.ODA
	which is a copy of the last HELP0.DAT that was successfully
	used.
							MSM 2/19/80
;
DEFINE RECORDS=[
XX(QUESTION,	"?",	"displays this information")
YY(QUESTION_X)
YY(MENU_X)
YY(UP_X)
YY(DONE_X)
YY(QQUESTION_X)
YY(HELP_X)
YY(BUGS_X)
YY(INFO_X)

XX(BUGS,	"BUGS",["what to do about apparent bugs"])
YY(BUGS_DES_X)
XX(BUGS_DES,NULL,	["	If there appear to be bugs, or something does
	not work the way you think it should, a good source is this helper or
	the AL USERS' MANUAL, which you should be familiar with if
	you are running this program by yourself.
		If either of these sources do not convince you it is not a bug,
	you can log down the error and what you were doing at the time, and
	your cusswords by getting out of the helper and typing these
	things between open and close brace pairs{}.  e.g. {arm refused to move}
	This will be treated as a comment, but will be recorded in a logging
	file.
		When you are done with POINTY, send or mail MSM a message
	saying that there were bugs, and complaints were logged in the
	logging file."])

XX(INFO,	NULL,	["
		Type one of the keywords on the left column.  If you
	don't understand any of this, type HELP.  The #### you see at the
	bottom of the screen is the prompt from the HELP module."])

XX(HELP,	"HELP",	["help on the use of this helper"])
YY(HELP_DES_X)
XX(HELP_DES,	NULL,	["	This helper is organized as a directed
	graph with loops, and to each node there corresponds a message.
	Terminal nodes have no keyword associated with them, whereas
	inside nodes do. (This means that you cannot go beyond the terminal
	node.)

		If the message is too long to fit on the screen,
	<formfeed> and <vert tab> may be used to scroll the text up and down
	the screen the way E does.  If the message can fit in one screenful
	<formfeed> and <vert tab> will have no effect.

		To get more information in the help mode, type legitimate
	keywords to the prompt #### at the bottom of the screen.
	Legitimate keywords are as follows:
		a) The list of keywords on the left hand column of the
	screen (if there are are any - there will be some unless you are
	looking at the terminal mode).
		b) The list of keywords on the left hand column of the
	screen the previous time.
		c) The list of keywords on the keyword stack at the
	bottom of the screen.

		Keywords are stacked as they are invoked, so that it is
	possible to tell the route by which you got to the current node.

		If you type a valid keyword, that keyword will appear
	as the last element of the keyword stack.  Since keywords
	are not repeated on the keyword stack, this means that sometimes
	the keyword stack may be trimmed back.

		If an invalid keyword is typed, it is as if you typed ?
	but the keyword stack will not be cut back.

		Note that you are now in a different mode.  Normal POINTY
	or AL commands will not work until you get out of the helper mode
	by using the DONE command.  When you reenter the HELP module at a
	later time, you will be in the state you left it.

		You can also invoke the HELP facility by giving an argument
	immediately after HELP and a space, and the facility will search
	through the keywords until it comes up with the particular keyword
	and it will display according to that keyword.  This is provided
	to produce immediate help on certain topics if the user wants to
	bypass the normal sequence of going through the beginning of
	chain of keywords.

	********* IMPORTANT NOTE *********  This HELP module is not designed
	to teach you to program in AL or POINTY.  Rather it is meant to
	be a description of the system, and the user is presumed to
	know a little bit about AL or POINTY by reading the AL USERS' MANUAL
	or talking to someone in the Stanford Hand-Eye project."])

XX(QQUESTION,	"??",	"ideas for other help topics")
YY(QQUESTION_DES_X)

XX(QQUESTION_DES,NULL,	["	If there is a help topic that you think should
	be here that isnt, please send a message to MSM about it, with
	suggestions for the text of the message and at what level it should be
	invoked.  Any suggestions will be seriously considered."])

XX(UP,		"UP",	"goes up a level on the keyword stack")

XX(MENU,	"MENU",	"gives a list of toplevel instructions")
YY(RES_WORDS_X)
YY(RES_HELP_X)
YY(DISPLAYS_X)
YY(POWER_X)
YY(PUMA_X)
YY(ELF_X)
YY(VT05_X)
YY(OPERATIONS_X)
YY(EXPRESSIONS_X)
YY(FILE_X)
YY(ESCAPE_I_X)
YY(STATEMENTS_X)
YY(ERROR_X)
YY(SYNTAX_X)
YY(DEBUG_X)
YY(SYSTEM_X)
YY(BAIL_X)
XX(RES_WORDS,	"RES",	"gives a list of reserved words")
YY(RESERVED_X)
XX(RESERVED,	NULL,	["These are reserved words:
	ABORT	ACOS	ADC	AFFIX	ALL	AND	ARRAY	ASIN	ATAN2
	AXIS		BAIL	BEGIN	BY		CALIB	CASE	CENTER
	CLOSE	COBEGIN	COEND	COMMENT	CONSTRUCT	COS
	DAC	DDT	DEFINE	DELETE	DISPLAY	DO	DRIVE	DUMP_VARIABLES
	ECHOOFF	ECHOON	EDIT	EEDIT	END	EQV	EVAL	EVENT
	EXIT	EXP	{FCONSTRUCT}	FOR	FRAME	FUNCTION
	GATHER	GRAPH	HELP	IF	INT	INTO	INV
	LOAD_VARIABLES
	MAX	MIN	MOD	MOVE	MOVEX	MOVEY	MOVEZ
	NODISPLAY	NOUPDATE	ON	OPEN	OR	ORIENT
	PARK	PCART	PFREE	PJOINT	POS	PRINT	PROCEDURE	PROMPT
	QBAIL	QREAD
	READ	READWRIST	REDEFINE	REDISPLAY	REFERENCE
	REL	RENAME	RESETSTATUS	RESUME_MESSAGE	RETURN	RETRY	ROT
	SAVECOREIMAGE	SCALAR	SETBASE	SETSTATUS	SETSTIFF	SHOW
	SIGNAL	SIN	SQRT	STOP	STOPMESSAGE	SUBTREE
	TAN	TO	TRANS	UNFIX	UNIT	UPDATE
	VALUE	VECTOR	VT05_OFF	VT05_ON
	WAIT	WHILE	WRIST	WRITE	WRT
	XCOORD	XOR	YCOORD	XCOORD"])
XX(RES_HELP,	"RESH",	"gives one line descriptions of the reserved words")
YY(RES_HELP_DES_X)

XX(RES_HELP_DES,NULL,	["ABORT	stops the current action and throws you into DDT
	ACOS	arc cosine
	ADC	analog to digital convertor input
	AFFIX	affix statement
	ALL	reserved word used with WRITE, DELETE, etc
	ARRAY	used for array declarations
	ASIN	arc sine
	ATAN2	arctangent taking two arguments
	BAIL	calls the SAIL debugger: not available in all versions
	BEGIN	denotes beginning of a block
	BY	reserved word used in MOVE, OPEN, CLOSE, AFFIX
	CASE	control statement
	CALIB	to allow turning on high power to pumas
	CLOSE	close the hand
	COBEGIN	parallel control
	COEND	indicates end of COBEGIN block
	COMMENT	comment statment: non executabl statement
	CONSTRUCT	makes a trans out of three vectors
	COS	cosine function
	DAC	digital to analog convertor output
	DDT	throws you into DDT: you better know what you are doing
	DEFINE	macro definitions
	DELETE	deletes variables
	DISPLAY displays appropriate data types
	DO	loop
	DUMP_VARIABLES	saves all the values of variables in a disk file
	DRIVE	moves individual joints
	ECHOOFF suppresses printing of input file: normal mode for QREAD
	ECHOON	prints out input file: normal mode for READ
	EDIT	edits values of variable or macro
	EEDIT	swaps to E for editing
	END	ends a block
	≡ EQV	equivalence
	EVAL	direct evaluation
	EVENT	event declaration
	EXIT	exits from POINTY, can resume by typing CONT
	EXP	exponentiation
	FCONSTRUCT	constructs frame from 3 transes
	FOR	loop iteration
	FRAME	frame definition or declaration
	FUNCTION	no longer valid
	GATHER	to gather data
	HELP	gets the help moe
	IF	if control statement
	INT	integer part of a scalar expression
	INTO	used for COPY/MERGE
	INV	inverse trans
	LOAD_VARIABLES	reads in the variables from a dump file
	LOG	logarithm
	MAX	maximum of two expressions
	MIN	minimum of two scalar expressions
	MOD	modulus (remainder)
	MOVE	general motion statement
	MOVEX	motion in the X direction
	MOVEY	motion in the Y direction
	MOVEZ	motion in the Z direction
	NODISPLAY	shuts off the display
	NOUPDATE	does not update the display
	ON	condition monitor or used in motion statement
	OPEN	pertains to the hand opening
	∨ OR	boolean OR operator
	ORIENT	the rotation part of a frame or trans
	PARK	parks the arm
	PCART	allows cartesian motions in the puma arm
	PFREE	free individual joints in the puma arm
	PJOINT	allow single joint motions in the puma arm
	POS	vector part of a frame or trans
	PRINT	prints arguments on the VT05
	PROCEDURE	procedure declaration
	PROMPT	waits for user to type P at the VT05
	QBAIL	like BAIL, but takes input from QUERY.TXT on current PPN
	QREAD	like READ, but does not print on terminal what is being read
	READ	reads in the appropriate file
	READWRIST	reads the wrist
	REDEFINE	changes definition of a macro
	REDISPLAY	gets the normal table mode
	REFERENCE	type of argument used for parameter specification
	REL	relative positons
	RENAME	change the name of a variable
	RESETSTATUS	change the value of compiler parameters to 0
	RESUME_MESSAGE	the message to print out when resuming execution
	RETURN	gets out of a procedure
	RETRY	performs the motion again; valid only within error condition monitor
	ROT	the rotation operator or declaration
	SAVECOREIMAGE	saves the state of the 10 and 11
	SCALAR	used for declarations
	SETBASE	assumes there is zero force on the wrist
	SETSTATUS	changes the values of compiler parameters
	SETSTIFF	sets wrist stiffness matrix
	SHOW	displays values of a list of variables
	SIGNAL	signals the event
	SIN	the sine function
	SQRT	the square root function
	STOPMESSAGE	message received from interjob mail system is ended
	TAN	tangent function
	TO	used in AFFIX,MOVE,OPEN
	TRANS	used for declaration and to make trans data type
	UNFIX	the UNFIX statement
	UNIT	computes a unit vector
	UPDATE	updates the display
	VALUE	used for declaration of procedure parameters
	VECTOR	constructing data type or declaring vectors
	VT05_OFF turns off updating of VT05
	VT05_ON	turns on updating of VT05 (default)
	WAIT	used with event
	WHILE	loop
	WRIST	reads the force wrist readings
	WRITE	writes AL declarations into a file
	WRT	operator
	XCOORD	refers to x-coordinate of a vector,trans or frame
	XOR	does exclusive or
	YCOORD	refers to y-coordinate of a vector,trans or frame
	ZCOORD	refers to z-coordinate of a vector,trans or frame"])
XX(DISPLAYS,	"DISP",	"describes display commands")
YY(DISPLAY_INFO_X)
XX(DISPLAY_INFO,NULL,	["The display commands relate to the display on the user
	and there are several modes of display: the table display mode (the
	display you get on starting up), the type display mode, the nodisplay
	mode, and the variable display mode.

	    NODISPLAY takes no arguments, shuts off displays
	    REDISPLAY gets you back into the table display mode
	    DISPLAY <type> displays all the variables of type <type>,
		where <type> may be SCALAR,VECTOR,ROT,TRANS,FRAME,
		EVENT,MACRO,PROCEDURE
	    UPDATE forces immediate update of the display
	    NOUPDATE prevents updating of the display
	    SHOW <variable list> displays the variables in the <variable list>"])
XX(POWER,	"POW",	"describes turning on and off the power to the arms")
YY(POWER_DES_X)

XX(POWER_DES,	NULL,	["	The main power supply to all the arms is turned
	on by pushing the red button on the underside of the short end of the
	hand eye table closest to the blue and yellow arms.
	The power supply to all the arms is turned off by pulling on the yellow
	cord running around the edge of the hand-eye table.

		Pressing the red button does not supply power to the PUMA arms
	directly.  If the PUMA arm is still under control of VAL, the PUMA
	program should be run to initialize and calibrate the PUMA arm.
	On the other hand, if the PUMA arm is directly controllable by AL,
	(or by POINTY as the case may be), it must first be turned on
	by typing CALIB(<GARM|RARM>).  When the instruction on the VT05
	asks if the PUMA is to be calibrated, press the black arm power
	button on the PUMA controller until the red LED light comes on,
	then type Y<RETURN> on the VT05 to let the PUMA be calibrated."])
XX(PUMA,	"PUMA",	"describes use of PUMA arms with POINTY")
YY(PPOWER_X)
YY(PMOTION_X)
YY(PKBD_X)

XX(PPOWER,   "PPOWER",	"describes how to supply power to PUMAs under POINTY")
YY(POWER_DES_X)

XX(PMOTION,	"PMOT",	"describes motion statements for PUMA")
YY(PMOTION_DES_X)

XX(PMOTION_DES,	NULL,	["	The PUMA arms can be moved under POINTY
	either directly through the runtime system or indirectly through
	the VAL system.  To be moved directly under POINTY requires
	a syntax similar to the motion statement for the BLUE arm or
	the YELLOW arm.  To move the PUMA under VAL, type the command
		VAL(""<VAL instruction>"");
	or	VAL(""<VAL instruction>"",WAIT);
	or	VAL(""<VAL instruction>"",NOWAIT);"])

XX(PKBD,	"PKBD",	"describes moving PUMA under joystick control")
YY(PKBD_DES_X)

XX(PKBD_DES,	NULL,	["	The PUMA arm can also be moved under keyboard
	control.  The following are the current statements to give the
	appropriate keyboard control.  The statements must be followed by
	RARM or GARM in parentheses.  For example PFREE is invoked by
	PFREE(GARM) or PFREE(RARM)

		PFREE	- to get joint free mode
		PTABLE	- to get cartesian motion mode in table coordinates
		PJOINT	- to get joint motion mode
		PTOOL	- to get cartesian motion in tool coordinates
		PGRAV	- to free up all the joints

	The VT05 will wait for a response.  The following pertains to
	characters typed on the VT05.

		For PFREE, typing the joint number will free the joint
	so it can be moved manually.  Typing any other character
	will cause the brakes to come on again.

		For PJOINT (when the arm is in joint control mode)
	Typing appropriate number determines the joint to move
		J	causes it to move in positive direction
		F	causes it to move in negative direction
		;	causes it to speed up subsequently
		A	causes it to slow down subsequently
		Q	causes it to quit VT05 keyboard mode
		any other character causes it to stop and wait for next
			character

		For PGRAV the arm should be statically balanced with the
	brakes off.  Typing any character will get you out of this mode.

		For PTABLE of PTOOL (when the arm is in cartesian motion mode)
	typing  J	causes motion in positive X direction
		F	causes motion in negative X direction
		K	causes motion in positive Y direction
		D	causes motion in negative Y direction
		L	causes motion in positive Z direction
		S	causes motion in negative Z direction
		;	causes subsequent motion to speed up
		A	causes subsequent motion to slow down
		Q	causes it to quit VT05 keyboard mode
		O	opens the hand
		C	closes the hand
		any other character causes PUMA to stop and wait for next
			character"])
XX(ELF,		"ELF",	["gives information on the ELF, or PDP-11 interface"])
YY(ELF_INFO_X)
YY(ELF_ASLEEP_X)

XX(ELF_INFO,	"ELFI",	"description of the ELF")
YY(ELF_INFO_DES_X)
XX(ELF_INFO_DES,NULL,	["	The ELF is the name given to the interface
	between the PDP-10 and PDP-11.  Before POINTY can be run successfully,
	the runtime system must be loaded and started across the ELF.  The
	ELF is a sharable device, which means that others may also use the
	interface.
		To get POINTY to work, type

			R POINTY<cr>

		If the ELF is being used by somebody else, you may
	be able to execute the program.  However, if someone else is using the
	arms, you will not be able to run POINTY.
		If the ARM is available, it will be assigned to your job
	and the POINTY program started on the PDP-11.
	Sometimes there may be errors that cause the
	program to stop executing and enter DDT.  When that happens,
	try to find out what is wrong, and get it to continue executing,
	normally by typing either <alt>P or RETRY<alt>G if you are
	asked to do so or the interactive part on the PDP-10 will not work.
	Don't type <alt>G or you will mess up whatever you did."])

XX(ELF_ASLEEP,	"ELFA",	"ELF asleep message")
YY(ELF_ASLEEP_DES_X)

XX(ELF_ASLEEP_DES,NULL,	["	ELF is asleep, I will keep trying to wake it
	until you type <ESC>I is the message you sometimes see printed at the
	terminal.  This gets printed out when the PDP-11 is in DDT, or it
	is stuck in some inner loop.  When the PDP-11 is in DDT, you will
	have to get it to proceed by typing <ALT>P or RETRY<ALT>G
	or FINISH<ALT>G.  If the PDP-11 is stuck in some inner loop, there
	is no easy way to get it unwedged, and the best thing to do is
	to start all over again.
	******* WARNING ****** NEVER TYPE <ALT>G to DDT while running this
	program unless you know what you are doing."])
XX(VT05,	"VT05",	"describes VT05")
YY(VT05_INFO_X)
XX(VT05_INFO,	NULL,	["The VT05 is a terminal directly connected to the PDP-11.
	It prints out the status of the arm joints and limits.
	VT05_ON prints out the joint angles continuously;
	VT05_OFF shuts off the printing of joint angles on VT05
	VT05_YELLOW displays the YELLOW ARM data
	VT05_BLUE displays the BLUE ARM data"])
XX(OPERATIONS,	"OPER",	"shows available operators and functions")
YY(LOGICALOPS_X)
YY(RELATIONALOPS_X)
YY(ARITHOPS_X)
YY(FUNCTIONS_X)
  XX(LOGICALOPS,"LOGIC","gives a list of logical operators")
YY(EQV_X)
YY(OR_X)
YY(AND_X)
YY(XOR_X)
YY(NOT_X)

XX(EQV,		NULL,	"≡    EQV	equivalence ")
XX(OR,		NULL,	"∨    OR	logical OR")
XX(XOR,		NULL, "⊗    XOR	exclusive OR")
XX(AND,		NULL, "∧    AND	logical AND")
XX(NOT,		NULL,	"¬		logical not")

  XX(RELATIONALOPS,"RELAT","list of relational operators")
YY(RELOPS_X)

XX(RELOPS,	NULL, "≤ < ≠ = > ≥	relational operators")
  XX(ARITHOPS,	"ARITH","gives a list of arithmetic operators")
YY(BINARYOPS_X)
YY(SCALAROPS_X)
YY(VECTOROPS_X)
YY(ROTOPS_X)
YY(FRAMEOPS_X)
YY(TRANSOPS_X)
YY(EXTRACTIONOPS_X)
YY(IMPLICITOPS_X)

    XX(BINARYOPS,"BIN",	"list of binary operators")
YY(PLUS_X)
YY(MINUS_X)
YY(TIMES_X)
YY(DIVISION_X)
YY(DIV_X)
YY(DOT_X)
YY(MAX_X)
YY(MIN_X)
YY(MOD_X)
YY(DIV_X)
YY(REL_X)
YY(WRT_X)
YY(BACKARROW_X)
YY(EXPON_X)
    XX(SCALAROPS,"SCOPS","list of operations that give a scalar result")
YY(SC_DES_X)

XX(SC_DES,	NULL,	["The following operations return a scalar value.
	These abbreviations are used: s = scalar,v = vector,r  = rotation,
	f = frame,t = trans.

	s + s		scalar addition
	s - s		scalar subtraction
	s * s		scalar multiplication
	s / s		scalar division
	s ↑ s		scalar raised to a scalar power
	s MAX s		maximum
	s MIN s		minimum
	INT(s)		integer part of s
	s DIV s		integer quotient after applying INT to each argument
	s MOD s		integer remainder after applying INT to each argument
	v . v		dot product of two vectors
	|s|		absolute value of a scalar
	|v|		magnitude of vector (vector norm)
	|r|		extracts angle of rotation
	INSCALAR	reads a scalar from the console

	Scalar functions
	SQRT(s)		square root
	SIN(s)		sine (all trigonometric functions are in degrees)
	COS(s)		cosine
	TAN(s)		tangent
	ASIN(s)		arc-sine
	ACOS(s)		arc-cosine
	ATAN2(s,s)	arc-tangent of s/s
	LOG(s)		natural logarithm
	EXP(s)		e raised to the s power

	s <rel> s	returns true if relation is satisfied, else false
			possible relations are: <,≤,=,≥,>,≠
	s ∧ s		logical and
	s ∨ s		logical or
	s ⊗ s		logical exclusive or
	s ≡ s		logical equivalence
	  ¬ s		logical not
	QUERY	reads a boolean from the console"])


    XX(VECTOROPS,"VTOPS","list of operations giving vector result")
YY(VEC_DES_X)

XX(VEC_DES,	NULL,	["The following operations return a scalar value.
	These abbreviations are used: s = scalar,v = vector,r  = rotation,
	f = frame,t = trans.

	VECTOR(s,s,s)	construct vector given (x,y,z) components
	s * v		dilation of a vector
	v / s		contraction of a vector
	v + v		vector addition
	v - v		vector subtraction
	v * v		vector cross product
	r * v		rotation of a vector
	t * v		transformation of a vector
	f * v		transformation of a vector - shorthand for (station → f) * v
	v WRT f		vector in station coordinates pointing
			the same way as v points in f's coordinate
			system.  v WRT f ≡ ORIENT(f)*v ≡ (f*v) - POS(f)
	UNIT(v)		vector of unit length with same direction as v
	POS(f)		vector position of frame or trans
	AXIS(r)		axis of rotation"])

    XX(ROTOPS,	"RTOPS","list of operations giving rot result")
YY(RT_DES_X)

XX(RT_DES,	NULL,	["The following operations return a scalar value.
	These abbreviations are used: s = scalar,v = vector,r  = rotation,
	f = frame,t = trans.

	ROT(v,s)	constructs rotation of s degrees about v
	ORIENT(f)	orientation of a frame or trans
	r * r		composition of two rotations (the one on the right
			is applied first)"])

    XX(FRAMEOPS,"FROPS","list of operations giving frame results")
YY(FR_DES_X)

XX(FR_DES,	NULL,	["The following operations return a frame value.
	These abbreviations are used: s = scalar,v = vector,r  = rotation,
	f = frame,t = trans.

	FRAME(r,v)	constructs frame of orientation r at position v
	CONSTRUCT(v,v,v)	makes a frame: first vector gives the position,
				second a point on the x-axis,
				third is a point in the xy-plane
	f + v		translation of a frame
	f - v		translation of a frame
	t * f		transformation of a frame
	f * f		transformation of a frame - shorthand for (station → f) * f"])

    XX(TRANSOPS,"TROPS","list of operations giving trans/frame result")
YY(TR_DES_X)

XX(TR_DES,	NULL,	["The following operations return a frame value.
	These abbreviations are used: s = scalar,v = vector,r  = rotation,
	f = frame,t = trans.

	TRANS(r,v)	constructs trans which will cause a rotation of r
			followed by a translation of v
	f → f		transformation which maps from the first frame
			to the second
	t * t		composition of two transes (the one on the right is
			applied first)
	INV(t)		take the inverse of t"])


    XX(EXTRACTIONOPS,"EXOPS","extraction functions")
YY(UNIT_X)
YY(ORIENT_X)
YY(AXIS_X)
YY(INV_X)
YY(INT_X)
YY(MAG_X)
    XX(IMPLICITOPS,	"IMPOPS","implicit data types")
YY(PAREN_X)

XX(PLUS,	NULL,	"+		addition")
XX(MINUS,	NULL,	"-		negation or difference")
XX(DOT,		NULL,	".		vector dot product")
XX(TIMES,	NULL,	"*		product")
XX(DIVISION,	NULL,	"/		division")
XX(MAX,		NULL,	"MAX		maximum of two operands")
XX(MIN,		NULL,	"MIN		minimum of two operands")
XX(DIV,		NULL,	"DIV		integer division quotient")
XX(MOD,		NULL,	"MOD		integer division remainder")
XX(REL,		NULL,	"REL		vector or trans relative to frame")
XX(WRT,		NULL,	"WRT		vector or trans with respect to frame")
XX(BACKARROW,	NULL,	"→		relative transform between two frames or transes")
XX(EXPON,	NULL,	"↑		exponentiation")
XX(ORIENT,	NULL,	"ORIENT		rotation part of a frame or trans")
XX(UNIT,	NULL,	"UNIT		conversion of a vector to unit vector")
XX(AXIS,	NULL,	"AXIS		the axis of rotation")
XX(INV,		NULL,	"INV		inverse of a rot or trans")
XX(INT,		NULL,	"INT		integer part of a scalar")
XX(CONSTRUCT,	NULL,	"CONSTRUCT	constructs a frame from 3 vectors")
XX(DOWN,	NULL,	"↓		downward orientation")
XX(STATION,	NULL,	"$		station orientation")
XX(ALPHA,	NULL,	"α		bpark orientation(???)")
XX(EVAL,	NULL,	["{EVAL		evaluate immediate}"])
XX(MAG,		NULL, ["|..|		magnitude of scalar or vector, or angle of rotation"])
XX(PAREN,	NULL,	["( .. )	implicit data type declaration"])
XX(DECL,	NULL,	"FRAME VECTOR TRANS ROT	make the appropriate data type")
XX(COORD,	NULL,	"XCOORD YCOORD ZCOORD    the relevant component of the vector or trans")
  XX(FUNCTIONS,	"FUNCT","gives a list of available functions")
YY(TRANSD_X)
YY(TRIG_X)
YY(SQRT_X)
YY(DOWN_X)
YY(ALPHA_X)
YY(STATION_X)
YY(CONSTRUCT_X)
YY(EVAL_X)
YY(PAREN_X)
YY(COORD_X)
YY(DECL_X)

XX(TRANSD,	NULL,	"LOG EXP	relevant transcendental functions")
XX(TRIG,	NULL,	"SIN COS TAN ASIN ACOS ATAN2	relevant trig functions")
XX(SQRT,	NULL,	"SQRT		square root function")
XX(EXPRESSIONS,	"EXP",	"valid expressions")
YY(EXP_DES_X)
YY(EXP_SYN_X)
YY(EXP_PRI_X)

XX(EXP_DES,	"OPS",	"types of expressions")
YY(EXPRESSIONS_DES_X)
XX(EXP_SYN,	"BNF",	"bnf definition of expressions")
YY(EXPRESSIONS_SYNTAX_X)
XX(EXP_PRI,	"PRI",	"priority of operators")
YY(EXPRESSIONS_PRIORITY_X)

XX(EXPRESSIONS_DES, NULL,["The following are valid expressions:
	S=scalar, V=vector,R=rot,T=trans,F=frame

	RESULT	OPERATION

	S:	S+S,S-S,S*S,S/S,S↑S,LOG(S),EXP(S),INT(S),S MAX S,S MIN S,
		SIN(S),COS(S),TAN(S),ASIN(S),ACOS(S),ATAN2(S,S),
		V.V
	V:	V+V,V-V,V*V,V*S,V/S,(S,S,S),VECTOR(S,S,S)
		POS(F),POS(T)
	R:	ROT(V,S),ORIENT(F)
	F:	FRAME(R,V)
	T:	TRANS(R,V),(R,V)"])

XX(EXPRESSIONS_SYNTAX,NULL,["The following is the recursive definition of
	expressions in bnf form:

	<expression>	::=	<befact>{{OR|XOR <befact>}}
	<befact>	::=	<bterm>{{AND <bterm>}}
	<bterm>		::=	<arith_exp>| <arith_exp> <rel> <arith_exp>
	<arith_exp>	::=	{+|-} <term> {{+|- <term>}}
	<term>		::=	<factor> {{*|/ <factor>}}
	<factor>	::=	<pfactor>{↑ <pfactor>}
	<pfactor>	::=	(<expression>) or |<expression>| or
				<constant> or <id> or ¬ <pfactor> or funct or
				funct(<expression>{{,<expression}})"])

XX(EXPRESSIONS_PRIORITY,NULL,["	The operators in AL generally follow
	normal precedence rules, i.e., functions are evaluated first,
	followed by exponentiations before multiplications or divisions,
	which in turn are performed before additions and subtractions.
	The order of operation can be changed by including parentheses
	at appropriate points.  In an expression where several operators
	of the same precedence occur at the same level, the operations
	are performed from left to right.

		functions, (), | |, NOT
		WRT → ↑
		* / . MAX MIN DIV MOD
		+ -
		= ≠ < > ≤ ≥
		∧
		∨ ⊗
		≡"])
XX(FILE,	"FILE",	"Gives the file management commands")
YY(PHOTO_X)
YY(WRITE_X)
YY(READ_X)
YY(LOAD_VARIABLES_X)
YY(DUMP_VARIABLES_X)
YY(SAVECOREIMAGE_X)

XX(PHOTO,	"PHOTO","Saves the terminal session")
YY(PHOTO_DES_X)
XX(WRITE,	"WRITE",["Saves AL declarations, macros, procedures and arrays"])
YY(WRITE_DES_X)
XX(READ,	"READ",	"Reads AL instructions from a disk file")
YY(READ_DES_X)
XX(LOAD_VARIABLES,"LOAD","Fast loads variables saved from a file")
YY(LOAD_VARIABLES_DES_X)
XX(DUMP_VARIABLES,"DUMP","Dumps variables into a file")
YY(DUMP_VARIABLES_DES_X)
XX(SAVECOREIMAGE, "SAVE","Saves the core image")
YY(SAVECOREIMAGE_DES_X)


XX(PHOTO_DES,	NULL,	["	When you run POINTY, your terminal session
	will be logged automatically into POINTY.PHT[PNT,HE].
	If you wish to record your session
	in another file as well, the command PHOTO <filename> will save
	the terminal input into <filename>.  Once PHOTO is called, it will
	keep on recording until you make another call to PHOTO in which case
	it will stop recording in the old file and start recording
	into the new file name.
		Recording can only be done into a file that is not being
	referenced by some other user or job, and the file is written out
	every 6 lines or so, so that if you accidentally kill your job
	or the system crashes (knock on wood!) you will have a record of
	your terminal session."])

XX(WRITE_DES,	NULL,	["	The write command permits the state of the world
	to be saved on a disk file. The syntax is as follows:

		WRITE ALL|<var_list> {INTO <filename>}

	The instruction will write the values of all the variables,
	arrays, macros or the selected ones into the relevant file.
	If the filename is not specified, it will be written into
	the last file into which AL declarations were written."])

XX(READ_DES,	NULL,	["	File input of AL commands can be done by means of
	the READ <filename> command.  The file will be read to completion unless
	<ESCAPE> I is typed.
		Note that defaults instructions will not work from file input,
	and that statements must be separated by semicolons."])

XX(LOAD_VARIABLES_DES,NULL,["	Fast loads variables and procedure and macro
	declarations from a file written out by the DUMP_VARIABLES command.
	The syntax is as follows:

		LOAD_VARIABLES <filename>

	This procedure can only be invoked at toplevel."])

XX(DUMP_VARIABLES_DES,NULL,["	Dumps variable values and procedure and macro
	declarations into a file in a form readable by the LOAD_VARIABLES
	command.  The syntax is as follows:

		DUMP_VARIABLES <filename>

	This command can only be invoked at top level."])

XX(SAVECOREIMAGE_DES,NULL,["	Saves the core image of the 10 and the 11.
	This command saves the entire state of the program in a dump file
	with extension .DMP.  The syntax is as follows:

		SAVECOREIMAGE <filename>

	Note that you will not be allowed to save a file called POINTY.DMP.
	(This is to protect against accidentally destroying the main
	core image that runs the POINTY system.)
	This will save a huge file (about 150K currently) and may easily
	send you over your disk allocation, so be sparing in its use.
	This command can only be invoked at top level.

		After saving the core image, the program will continue
	executing.  If you want to get this state back at a later
	time, you can do so by doing the monitor command

		RU <filename>

		If you would like the new program to print out a message
	when it is executed subsequently, type RESUME_MESSAGE(<message>)
	before you type SAVECOREIMAGE."])
XX(ESCAPE_I,	"ESC_I","ESCAPE I command")
YY(ESCAPE_I_DES_X)
XX(ESCAPE_I_DES,NULL,	["	Hitting the <ESC> key followed by an I will
	interrupt whatever the PDP-10 is doing and throw you back to the
	top level.  Any type ahead will be destroyed.  If a file is being
	read, the rest of the file will be ignored.
		This command is useful when there is some error in the
	input file which causes the generation of a large number of error
	messages, and you want to get command back to top level.
		A second place this command is useful is when
	there is some problem on the 11 and the system seems to be wedged.
	In this case it is still possible to save the values of variables
	that the PDP-10 knows about and start over.
		Typing <esc> I may not work if it is done during
	initialization, since the interrupt is not enabled at the
	end of initialization."])
XX(STATEMENTS,	"STATE","classes of statements")
YY(ASSIGNMENT_X)
YY(MOTION_X)
YY(DECLARATION_X)
YY(CONTROL_X)
YY(OTHER_AL_X)
YY(INTER_X)

  XX(ASSIGNMENT,["←"],	"assignment statement")
YY(ASSIGNMENT_DES_X)

XX(ASSIGNMENT_DES,NULL,	["	The assignment statement is of the form

		<variable> ← <expression>
	or	component(<variable>) ← <expression>

	where component is XCOORD,YCOORD,ZCOORD,POS or ORIENT.
	The data types on both sides of the assignment statement must
	be the same for the assignment to work, except that trans
	expressions may be assigned to frames.

		In the first form, if <variable> has not been declared,
	POINTY will declare it to be the same data type as the expression
	on the right hand side.  Predefined variables or constants
	like BARM, YARM, BHAND, YHAND, XHAT,YHAT,ZHAT,NILVECT may
	not have values assigned to them.

		The planning assignment operator ←← of AL is recognized
	and parsed, but is essentially a NOOP execpt that it serves
	to declare the variable on the left hand side if it has not
	already been declared."])

  XX(MOTION,	"MOT",	"list of motion commands")
YY(OPEN_X)
YY(CLOSE_X)
YY(MOVE_X)
YY(DRIVE_X)
YY(CENTER_X)
YY(GATHER_X)
YY(GRAPH_X)

    XX(OPEN,	"OPEN",	"opens the hand")
YY(OPEN_DES_X)

    XX(CLOSE,	"CLOS",	"similar to OPEN")
YY(OPEN_DES_X)

XX(OPEN_DES,	NULL,	["	The OPEN/CLOSE command applied to
	a hand causes the hand opening to go to the desired value.
	The syntax is as follows:

		OPEN <hand> TO|BY <scalar_exp>
		CLOSE <hand> TO|BY <scalar_exp>

	permitting the use of an absolute or relative value.
	Note that OPEN bhand BY 1 is the same as CLOSE bhand BY -1."])

    XX(MOVE,	"MOVE",	"moves the arm")
YY(MOVE_DES_X)
XX(MOVE_DES,	NULL,	["	The MOVE command specifies the motion of
	the specified frame to the desired destination which may
	be in absolute or relative terms. The syntax is as follows:
		MOVE <frame> TO <dest>
			<VIA clauses>
			<condition monitors>
			<clauses>

		The VIA clause may come just after MOVE <frame> or after
	TO <framefinal> or after the conidition monitors or clauses.
	Note that condition monitors and clauses may be mixed.
	There are two forms of the VIA clause.  One is the form
	where VIA is followed by a list of frame positions separated by
	commas as follows:
			VIA <frame1>,<frame2>,<frame3>,...<framen>
		in which case you can have only one VIA clause.
	In the other form, one intermediate location is given, but there are
	qualifying clauses after the location as follows:
			VIA <framei> WHERE DURATION = n
				WITH VELOCITY =...
				WITH SPEED_FACTOR = ...
				THEN <statement>
	where any of the qualifying clauses are optional.

		Currently the condition monitors available are
	the FORCE and TORQUE, ERROR, DURATION, EXPRESSION, and EVENT
	condition monitors whose syntax are as follows:
		ON FORCE(direction) <rel> <scalar_exp> {IN HAND|STATION}
			DO <statement>
		where <rel> is ≥ or < and direction is XHAT,YHAT, or ZHAT

		ON ERROR=<compile time constant> DO <statement>.
		ON DURATION > <scalar_exp> DO <statement>
		ON <scalar_exp> DO <statement>
		ON <event_id> DO <statement>

	In <statement> it is possible to ask for RETRY and the current
	motion command will be executed.  The compile time constant must
	set certain bits, and may be abbreviated by means of the following
	macros which are already predefined:
		DEFINE PANIC_BUTTON=⊂ 1024⊃;    { = '2000 }
		DEFINE EXCESSIVE_FORCE=⊂ 2048⊃;	{ ='4000  }
		DEFINE TIME_OUT=⊂ 4096⊃;	{ ='10000 }

		Clauses available are the DURATION, STIFFNESS, WRIST
	ZEROED/NOT ZEROED, WOBBLE, SPEED_FACTOR, FORCE_FRAME
	with the following syntax:

		WITH DURATION=n		where n is a compile time constant
		WITH STIFFNESS = (<vect>,<vect>,<trans>) 
		WITH STIFFNESS = (<vect>,<vect>) AT <trans>
		WITH WRIST ZEROED
		WITH WRIST NOT ZEROED
		WITH WOBBLE=n		where n is a compile time constant
		WITH SPEED_FACTOR = n	where n is a compile time constant
		WITH FORCE_FRAME = <trans> {IN HAND|STATION}"])
    XX(DRIVE,	"DRIVE","driving single joints")
YY(DRIVE_DES_X)
XX(DRIVE_DES,	NULL,["	The DRIVE command is a motion command that permits
	driving single joints.  The syntax is as follows:

		DRIVE <BJT|YJT>(n) <TO|BY> <amt>

	where n is the joint number to be driver, <amt> is amount to be
	driven in degrees or inches (depending on the joint), and 
	BJT refers to the blue arm and YJT refers to the yellow arm.
	At the moment this instruction does not work with the PUMA arms.
	You might want to try the PJOINT instruction, though."])
    XX(CENTER,	"CENTER","does a grasp")
YY(CENTER_DES_X)
XX(CENTER_DES,	NULL,	["	The CENTER command does adaptive grasping.
	The fingers move towards each other until one finger makes contact.
	Keeping this finger in contact with the object, the hand closes
	while the arm adjusts itself until the other finger makes contact
	at which time the object has been grasped.

	The syntax is as follows:

		CENTER <arm>"])

    XX(GATHER,	"GATH","gathers force and torque data")
YY(GATHER_DES_X)

XX(GATHER_DES,	NULL,	["	The GATHER command is used for collecting
	force data during the next motion.  You should put in as many
	components as you are interested in.  The syntax is as follows:

				GATHER(c1,c2,...,cn)

	where c1,c2,..cn are components and may be any of the terms
	FX,FY,FZ,MX,MY,MZ,T1,T2,T3,T4,T5,T6,TBL.  The first six represent
	forces and torques in the principal directions.  If TBL is specified,
	the quantities are in table coordinates, otherwise in hand coordinates.
	T1 thru T6 represent forces measured according to joints.

		The gather command sets up the preparatory commands
	for the next motion command, and after the next interaction
	with the runtime system which involves a motion, the data
	will be read back into POINTY and be available to be examined by
	the GRAPH command."])

    XX(GRAPH,	"GRAPH","explains the GRAPH command")
YY(GRAPH_DES_X)

XX(GRAPH_DES,	NULL,	["	The syntax of the graph command is simply
	GRAPH.  This command gets you into the module which helps to
	plot and save force data on a disk file or display on a data disc.
	This command is valid only after a GATHER and move.  On exiting
	the GRAPH module, the data is destroyed in order to reclaim the
	space which the data occupies for some other purpose."])
  XX(DECLARATION,	"DECL",	"declaration statement")
YY(DECLARATION_DES_X)

XX(DECLARATION_DES,NULL,["	Declarations may be made explicitly as
	in the case of AL, or implicitly by means of assignment statements.
	Explicit declarations may be made by means of the following
	syntactical construct:

		<data_type> <variable list>
	where <data_type> is one of SCALAR, VECTOR, ROT, TRANS, FRAME or
	EVENT.  <variable list> consists of a series of identifiers
	separated by commas.

		Arrays may be declared by including ARRAY after the data type,
	e.g.
		SCALAR ARRAY S[1:10,3:5]

	The indices may be constants or scalar expressions.  Scalar
	arrays will be initialized to 0, vector arrays to nilvect,
	rot arrays to nilrot, trans and frame arrays to niltrans.

		Macros are declared by means of the DEFINE statement,
	while procedures declarations are described in detail elsewhere."])

  XX(CONTROL,	"CONT",	"list of control statements")
YY(IF_X)
YY(FOR_X)
YY(DO_X)
YY(WHILE_X)

XX(IF,		"IF",	"IF statement")
YY(IF_DES_X)
XX(IF_DES,	NULL,	["	The IF statement has the following syntax:

		IF <scalar exp> THEN <statement>
	or	IF <scalar exp> THEN <statement> ELSE <statement>

		The IF statement cannot be used as an expression."])
XX(FOR,		"FOR",	"FOR statement")
YY(FOR_DES_X)
XX(FOR_DES,	NULL,	["	The FOR statement has the following syntax:

		FOR <scalar> ← <scal exp> STEP <scal exp> UNTIL <scal exp>
			DO <statement>"])

XX(DO,		"DO",	"DO statement")
YY(DO_DES_X)
XX(DO_DES,	NULL,	["	The DO statement has the following syntax:

		DO <statement> UNTIL <condition>

	<statement> will be executed until <condition> becomes TRUE"])

XX(WHILE,	"WHILE","WHILE statement")
YY(WHILE_DES_X)
XX(WHILE_DES,	NULL,	["	The WHILE statement has the following syntax:

		WHILE <cond> DO <statement>

	<cond> is a scalar expression, and is checked.  If it is TRUE( non zero)
	<statement> is executed and the <cond> checked and <statement>
	executed and the sequence repeated until <cond> becomes FALSE(0)."])

  XX(OTHER_AL,	"OTHERS","these are some of the other AL instructions")
YY(COMMENT_X)

XX(COMMENT,	"COMM",	"this describes use of COMMENTS")
YY(COMMENT_DES_X)

XX(COMMENT_DES,	NULL,["	There are two forms of comment statements.
	The first form is having the reserved word COMMENT followed
	by anything and ended by a semicolon.  The second
	form is enclosing the comment between open and close brace pairs
	e.g. {this is a comment} which may appear anywhere.  Note that
	the delimiters may be nested."])

  XX(INTER,	"INTER","these instructions facilitate interaction")
YY(EDIT_X)
YY(EEDIT_X)
YY(DELETE_X)
YY(DISPLAYS_X)
YY(GATHER_X)
YY(SETSTATUS_X)

    XX(EDIT,	"EDIT",	"permits the changing of the value of simple variables")
YY(EDIT_DES_X)
XX(EDIT_DES,	NULL,	["	The EDIT command displays the values of
	variables to be displayed in the line editor
	and permits the user to change their values.  The syntax of the
	command is as follows:

			EDIT <variable name>

	where <variable name> is the name of the appropriate variable to be
	changed.  Currently only scalars, vectors, transes, rots or frames
	variables which are not arrays may be edited.  Macros may also be
	edited by means of this command.
		The EDIT command argument is sticky, i.e. if a variable
	name is not given, it will assume that it is the last variable that
	was edited."])

    XX(EEDIT,	"EEDIT","writes the macro in a file and swaps to E")
YY(EEDIT_DES_X)
XX(EEDIT_DES,	NULL,	["	The EEDIT command takes a macro name
	as argument and writes it out into a disk file.  The core image
	is then saved, and the program swaps to E where the user is
	permitted to make changes to the macro body.  This is particularly
	useful when the macro body is a long one and many changes need
	to be made to it.  Minor changes may be made by means of the
	EDIT command.
		When you are satisfied with the macro, type <control>X RUN
	and you will get back to POINTY.  In the meantime please make sure
	not to change the state of the program on the PDP-11."])


    XX(DELETE,	"DEL",	"deletes some or all variables")
YY(DELETE_DES_X)

XX(DELETE_DES,	NULL,	["	The DELETE command deletes all the user
	defined variables or some of them.  The syntax is as follows:

			DELETE ALL
			DELETE <variable list>

		In the first form, all user declared variables are
	deleted after asking for confirmation. In the second form
	POINTY will complain if some of the variables in the list are
	non existent.  In the second form, frame arrays may not be
	deleted.  Also, individual elements of an array may not
	be deleted.

		A more liberal form of the instruction is executed
	if DELETE is replaced by QDELETE.  In the first form, confirmation
	is not asked for, while in the second form, POINTY does not
	complain if the name in the variable list is non existent."])

    XX(SETSTATUS,"SETS","explains the SETSTATUS and RESETSTATUS commands")
YY(SETSTATUS_DES_X)

XX(SETSTATUS_DES,NULL,	["	The SETSTATUS and RESETSTATUS commands
	are used to set compiler variables.  The syntax is as follows:
		SETSTATUS(<var>,<value>)
		RESETSTATUS(<var>,<value>)
	If <value> is left out, it defaults to 1 in the case of SETSTATUS
	and 0 in the case of RESETSTATUS.  <var> currently may be the
	following:

		NOELF	- no output to the ELF
		NOFOLD	- no constant folding and evaluation of constant
			  scalars and reals
		LINE	- prints out the expanded version of the last
			  statement on the terminal
		PPCODE	- the pcode of the statement being parsed will
			  printed out at the terminal
		PWCODE	- the pcode of the statement being parsed will be
			  appended to the file PPCODE.FOO
		ALPRIN	- subsequent printout of variables in AL format
			  rather than POINTY format
		PRTIME	- prints the execution time for the current
			  instruction
		DEBUG	- gets you in debug mode which allows source level
			  break pointing, single stepping, etc"])
XX(ERROR,	"ERROR", "talks about how to handle errors")
YY(NO_ARM_X)
YY(PARSE_X)
  XX(NO_ARM,	"NOARM", "what to do if there is no arm action")
YY(NO_ARM_DES_X)
XX(NO_ARM_DES,	NULL,	["	When the arm does not do what you expect
	it to do, namely move, there will probably be a message printed
	out at the VT05 console which may explain the error.
		One of the commonest forms of errors is that the power
	supply is off or one of the brake switches is off.  For the
	former, turn on the arm motor power by hitting the big red
	button on the underside of one of the short sides of the table.
		Sometimes the arm seems to move in weird fashions,
	or will claim that it cannot move to the PARK position!
	When this happens, it may be that the arm is not properly
	initialised.  In this case, just reload and start the system
	again.
		There are several forms of recovery.
	RETRY<alt>G at the VT05 will try to repeat the motion.
	<alt>P will go on with the next instruction.
	FINISH<alt>G will cause the arm to go to its destination directly.

		DO NOT ever type <alt>G during execution
	of POINTY since this will throw the synchronization out, unless
	you know what you are doing."])
  XX(PARSE,	"PARSE", "explanation of error messages")
YY(PARSE_DES_X)
XX(PARSE_DES,	NULL,	["	POINTY is based on the assumption
	that it will be used interactively, and any errors encountered
	during parsing a statement results in abandoning any further
	processing and giving control back to the user.
		This may cause grief if move commands
	and errors occur in a disk file instead of in the terminal
	input mode.
		It also means that if you are trying to write
	a long program interactively you better not make any typing
	mistakes, or you will have to start over.
		It is much easier to build up programs as macros
	and to edit the macros if they do not behave as you think they
	should.  When you are happy with the macros, declare a procedure
	with the appropriate macro as body."])
XX(SYNTAX,	"SYNTAX","syntax of statements")
YY(SYNFILE_X)
YY(SYNDIS_X)
YY(SYNDECL_X)
YY(SYNMIS_X)
  XX(SYNFILE,	"FILSYN","syntax of file management commands")
YY(FILE_SYN_X)

XX(FILE_SYN,	NULL,	["	WRITE ALL INTO <filename>
	WRITE <variable list> INTO <filename>
	WRITE ALL INTO <filename>
	WRITE INTO <filename>
	READ <filename>
	QREAD <filename>
	LOAD_VARIABLES <filename>
	DUMP_VARIABLES <filename>
	SAVECOREIMAGE <filename>"])

  XX(SYNDIS,	"DISSYN","syntax of display commands")
YY(DISPLAY_SYN_X)

XX(DISPLAY_SYN,	NULL,	["	REDISPLAY
	NODISPLAY
	DISPLAY <SCALAR|VECTOR|ROT|TRANS|FRAME|EVENT>
	SHOW <variable list>
	VT05_ON
	VT05_OFF"])

  XX(SYNDECL,	"DECL",	"syntax of declaration commands")
YY(VARDECL_X)
YY(PRCDECL_X)
YY(MACDECL_X)

XX(VARDECL,	"VARDEC","variable declaration")
YY(DECL_SYN_X)
XX(DECL_SYN,	NULL,	["	SCALAR s1,s2,s3,.....
	VECTOR v1,v2,v3,...
	ROT r1,r2,r3,...
	TRANS t1,t2,t3,...
	FRAME f1,f2,f3,...
	EVENT e1,e2,e3,...
	<SCALAR|VECTOR|ROT|TRANS|FRAME|EVENT> ARRAY a[l1:u1,l2:u2,...ln:un]"])

XX(PRCDECL,	"PRCDEC","procedure declaration")
YY(PRC_SYN_X)
XX(PRC_SYN,	NULL,	["	Procedure declarations are as in SAIL,
	and are fully recursive, may take parameters with defaults defined"])

XX(MACDECL,	"MACDEC","macro declaration")
YY(MAC_SYN_X)
XX(MAC_SYN,	NULL,	["	Macro declarations are as in SAIL,
	and will take default values"])
  XX(SYNMIS,	NULL,	["	Syntax of other commands will be added
	at a later date.  If you would like to see them soon, please send
	or mail a message to MSM."])
XX(DONE,	"DONE",	"quits help mode")
XX(DEBUG,	"DEBUG","details of the high level debugger")
YY(DEBUG_INFO_X)

XX(DEBUG_INFO,	NULL,	["
	DOCUMENTATION OF THE DEBUGGING FACILITIES IN POINTY
	---------------------------------------------------

	To set POINTY in debug mode the instruction
		SETSTATUS(DEBUG)  or 
		DEBUGON
	are required. You can reset POINTY to the normal mode by typing
		RESETSTATUS(DEBUG) or 
		DEBUGOFF

	When in  debug mode  POINTY will  stop at  the beginning  of any  compound
	statement you type  in, while  it doesn't  stop if  you  type in a  simple
	statement.

	When in debug mode  POINTY reads general POINTY  expressions typed by  the
	user, evaluates them  in the  context of the  place in  the program  where
	execution was suspended.  The evaluation is performed just as if the  user
	had inserted an  extra statement into  the original program  at the  point
	where execution was suspended.   The user may ask  to evaluate any  POINTY
	expression whose  evaluation would  be legal  at the  point at  which  the
	execution of the program was suspended.

	POINTY prompts the user for input by typing a ⊂:*:⊃.  Input can be  edited
	using the standard line editor.  The activation character is the semicolon
	or the carriage return, whathever comes first.

	The POINTY  instructions  typed are  numbered  starting from  1,  so  that
	reference  to  an  instruction  can   be  done  through  its  number,   or
	referred to as coordinate.


	--------------------------------------------------------------------------
	Here is the list of instructions available ONLY in debug mode:
	--------------------------------------------------------------------------

		BREAK(COORD)
		BREAK(""PROCEDURE_NAME"", COORD)
	Put a breakpoint at the specified point. 

		HALT
	Send the control to the 10.

		TEXT
		TEXT(MIN#)
		TEXT(MIN#,MAX#)
		TEXT(""PROCEDURE_NAME"",MIN#)
		TEXT(""PROCEDURE_NAME"",MIN#,MAX#)
	Show the source text,  from MIN# to MAX#.  If MAX# < MIN#  set MAX# to  be
	MIN#+MAX#. If MAX#  is omitted  set it  to be  MIN#. If  both numbers  are
	omitted show the next instruction to be executed.
	
		RESTART						   
	Restart the program from the beginning.   Can be called only when  outside
	from procedures.

		TRAPS
	Show the exixting breakpoints.

		UNBREAK(COORD)
		UNBREAK(""PROCEDURE_NAME"", COORD)
	Remove a breakpoint from  the specified point.  Complain if no  breakpoint
	has been set.

		!!GO, <CONTROL>G
	Continue the execution, from the point where it was suspended.

		!!STEP, <CONTROL>S
	Execute next statement and stop after that.

		!!GSTEP, <CONTROL>X
	Execute next statement, considering compound statement or procedure  calls
	as a single statement, and stops after that.

	--------------------------------------------------------------------------
	KNOWN BUGS
	--------------------------------------------------------------------------

	TRAPS shows the breakpoints in the main program and in untyped  procedures
	(doesn't work yet for typed procedures)

	COBEGIN/COEND cause severe problems. Don't try it!
	"])
XX(SYSTEM,	"SYSTEM","building up a new POINTY system")
YY(SYS10_X)
YY(SYS11_X)
YY(SYSALL_X)

XX(SYS10,	"SYS10", "building up system on the PDP-10")
YY(SYS10_INFO_X)

XX(SYS10_INFO,	NULL,	["	The system on the PDP-10 part can be built up
	easily by means of the instruction ""DO PCOMP[PNT,HE]"". This DO
	file deletes all the .REL files which are no longer valid, rewrites
	INTOPS.SAI, and then proceeds to compile each of the files in the
	POINTY system separately.  It then loads the files and writes
	out the PDP-10 part of the POINTY system as PONTY0.
	When it is done, it sends and mails a message saying it has completed
	its job.

	***** CAUTION ****** This is given only as a matter of information.
	Don't fool around with all these unless you are one of the people
	working with the system."])

XX(SYS11,	"SYS11", "building up the POINTY runtime system")
YY(SYS11_INFO_X)

XX(SYS11_INFO,	NULL,	["	There are four parts to the RUNTIME system and
	generally two parts have to be reassembled.  Reassamble POINTY.PAL
	and PNTARM.PAL on [PNT,HE], and these files will automatically call
	in AL.PAL and ARM.PAL respectively.  Then to load up the 11 and
	get a .SAV file do the following (the stuff after the semicolons are
	comments for your information):

		.A ARM			; assigns arm to your job
		.R 11TTY		; runs 11TTY program
		*Z500000		; Zeroes 500000 words of core
		*LPOINTY[PNT,HE]	; Loads AL runtime interpreter
		*OPNTARM[PNT,HE]	; overlays arm code. if you need symbols
					; as well use M instead of O
		*OK1[11,SYS]		; overlays the kernal
		*OPNTY[PNT,HE]		; overlays the AL program with data
					; structures
		*W160000		; writes a 1 into 160000 to tell AL
		*1			; runtime interpreter that this is
					; a POINTY system
		*ATERM			; put the terminal into VT05 mode
		*VT05

		*SD	<now on the VT05 type <alt>G and wait for scanning>
		*ATOP			; set top address to be saved to 500000
		*500000
		*DPOINTY		; dumps the runtime system in the
					; file POINTY.SAV
		*X			; exits from 11TTY back to monitor
		.

	***** CAUTION ****** This is given only as a matter of information.
	Don't fool around with all these unless you are one of the people
	working with the system."])

XX(SYSALL,	"SYSALL",	"describes building up the POINTY system")
YY(SYSALL_INFO_X)

XX(SYSALL_INFO,	NULL,	["	The part on the 10 and the runtime must first be
	built up, as described in SYS10 and SYS11.  Then do the following:

		.A ARM
		.R 11TTY
		*GPOINTY[PNT,HE]
		*X
		.RU PONTY0[PNT,HE]

	When everything is working fine, type the instruction

		SAVECOREIMAGE P0

	The coreimage of both the parser on the 10 and the runtime system
	on the the 11 will be saved in a file named P0.  To resume the
	execution at a later date, type RU P0.  If you want to get at this
	file by means of R POINTY, then rename this file POINTY.DMP[PNT,HE]
	by means of the RENAME command as follows:

		RENAME POINTY.DMP[PNT,HE]←P0.DMP

	***** CAUTION ****** This is given only as a matter of information.
	Don't fool around with all these unless you are one of the people
	working with the system."])
XX(BAIL,	"BAIL",	"describes the SAIL debugger and how to get at it")
YY(BAIL_DES_X)

XX(BAIL_DES,	NULL,	["	To get the SAIL debugger in helping to debug
	the system, type BAIL or BAIL(<list of BAIL instructions>).
	This is applicable only if BAIL is loaded with the system,
	(which will be done if POINTY.SAI and the files of interest are
	compiled with a 27B, compilation).
		An alternate way of getting at BAIL and not having to
	type in repetitive instructions is to put those instructions into
	a file called QUERY.TXT and that file will be read in if BAIL is
	invoked with the QBAIL instruction.
		While in BAIL, several variables are available for
	general use.  Thus !!i1,!!i2,!!i3,!!i4,!!i5,!!i6 are six integers
	and !!r1,!!r2,!!r3,!!r4,!!r5,!!r6 are six record pointers.

		This information is relevant only if you are working with
	the POINTY or AL INTERPRETER system."])
];